/**
 * axios封装
 * 请求拦截、响应拦截、错误统一处理
 */
import { message } from 'antd';
import axios from 'axios';
import store from '../store';
import { JSONObject } from '../admin/schema/common';
import Cookies from 'js-cookie';
// import baseUrl from "./baseUrl";

const instance = axios.create({
  baseURL: process.env.REACT_APP_API_URL,
  timeout: 90000,
  // 如果要使用Content-Type:application/x-www-form-urlencoded; 打开这里的注释即可
  // transformRequest: [
  //   function(data, headers) {
  //     return Qs.stringify(data);
  //   }
  // ]
});

/**
 * 请求拦截器
 * 每次请求前，如果存在token则在请求头中携带token
 */
instance.interceptors.request.use(
  config => {
    const token = (store.getState() as JSONObject).token;
    const uniqueToken = (store.getState() as JSONObject).uniqueToken;
    const encryptToken = (store.getState() as JSONObject).encryptToken;
    config.withCredentials = true;
    // config.headers.Authorization = token;

    if (token) {
      /**
       * 未找到同一获取设置token的地方
       * 在每次请求前获取token，设置session 添加token
       * 修复网页非ajax请求时获取不到token的问题
       */
      Cookies.set('SESSION_TOKEN', token);
    }

    // if (encryptToken && config.url.startsWith('/weathersms')) {
    //   config.headers.encryptToken = encryptToken;
    // }

    if (uniqueToken && (config.url.startsWith('/cas') || config.url.startsWith('/rocket-api'))) {
      config.headers.uniqueToken = uniqueToken;
      config.headers.userId = (store.getState() as JSONObject)?.loginInfo?.id;
    } else {
      config.headers.encryptToken = encryptToken;
    }

    return config;
  },
  error => Promise.reject(error)
);

// 响应拦截器
instance.interceptors.response.use(
  // 请求成功：res.status为200
  res => {
    const { config, data } = res;
    const { code } = data;

    if (config.url.startsWith('/cas') || config.url.startsWith('/rocket-api')) {
      if (
        ['/cas/passport/session', '/cas/passport/captcha', '/cas/api/messages/poll'].includes(
          config.url
        )
      ) {
        return Promise.resolve(data);
      }

      if (config.responseType === 'blob') {
        return Promise.resolve(data);
      }
      // 特殊处理-cas登录接口
      if (data.status === 200 || data.status === '200') {
        // 登录成功
        return Promise.resolve(data);
      } else {
        message.error(`${data.msg || '服务器繁忙，请稍后重试'}`);
        return Promise.reject(data);
      }
    } else if (config.onDownloadProgress) {
      // 特殊处理-机器人导出下载接口，合成音频文件接口
      return Promise.resolve(data);
    } else if (code === 0) {
      // 请求code为0代表成功
      return Promise.resolve(data);
    } else {
      if ([130009, 130008, 130017].includes(code)) {
        // 批量上传录音文件：模板中的话术ID不存在
        return Promise.reject(data);
      }
      if ([150013].includes(code)) {
        // 批量学习中
        message.info('当前正在批量学习中，请稍后再试');
        setTimeout(() => window.location.reload(), 300);
        return Promise.reject(data);
      }
      if ([30021].includes(code)) {
        // 流程编辑中，锁定
        return Promise.resolve(data);
      }
      // 其他code码：服务器异常
      message.error(`${data.tips ?? data.msg ?? ''}`);
      return Promise.reject(data);
    }
  },
  // 请求失败：res.status不为200
  error => {
    if (!error || !error.response || !error.response.data) {
      message.error('系统繁忙，请稍后再试~');
      console.log('错误信息', error);
      return Promise.reject(error);
    }
    const res = error.response.data;
    if ([100005, 10006, 100007, 10007, 10011, 10012].includes(res.code)) {
      if (!(store.getState() as JSONObject).token) {
        message.warn('抱歉，您还未登录系统，正在前往登录页面');
      } else {
        message.warn('token 过期，请重新登录');
      }
      // debugger;
      // if (process.env.REACT_APP_LOGIN_NO_CHECK != '1') {
      //   localStorage.clear();
      //   window.location.href = '/webapp/login';
      // }

      return Promise.reject(error);
    }

    message.error(`${res.msg || '服务器繁忙，请稍后重试'}(错误码: ${res.code || 500})`);
    return Promise.reject(error);
  }
);

/**
 * 约束request入参
 */
type RequestOption = {
  /**
   * 请求相对地址
   */
  url: string;
  /**
   * 请求参数
   */
  data?: any;
  /**
   * content-type
   */
  contentType?: string;
};

export default {
  get(option: RequestOption, config?: any): Promise<any> {
    return instance({
      url: option.url,
      params: { ...option.data, ...{ timestamp: +new Date() } },
      ...config, // 其他配置，如：定义blob类型，超时时间
    });
  },
  post(option: RequestOption, config?: any): Promise<any> {
    return instance({
      method: 'POST',
      url: option.url,
      data: option.data,
      headers: {
        'content-type': option.contentType,
      },
      ...config, // 其他配置，如：定义blob类型，超时时间
    });
  },
  delete(option: RequestOption): Promise<any> {
    return instance({
      method: 'DELETE',
      url: option.url,
      data: option.data,
      headers: {
        'content-type': option.contentType,
      },
    });
  },
  put(option: RequestOption): Promise<any> {
    return instance({
      method: 'PUT',
      url: option.url,
      data: option.data,
      headers: {
        'content-type': option.contentType,
      },
    });
  },
  patch(option: RequestOption, config?: any): Promise<any> {
    return instance({
      method: 'PATCH',
      url: option.url,
      data: option.data,
      headers: {
        'content-type': option.contentType,
      },
      ...config, // 其他配置，如：定义blob类型，超时时间
    });
  },
};

/**
 * async await调用接口时，抹平try catch
 * @param {*} promise
 * @param {*} errorTxt
 * @returns { response: {} = {}, error }
 * const { response: {}, error } = await flatTryCatch()
 */
export const flatTryCatch = (promise: Promise<any>, errorTxt?: string): Promise<any> =>
  promise
    .then((response = {}) => ({ response }))
    .catch(err => ({ response: {}, error: errorTxt ?? err }))
    .finally();
